Mental situations

	(McCarthy 1960) proposes an Advice Taker program that would represent what it
knew by logical sentences and decide what to do by logical inference.
That paper further promised that even the heuristics that guide the reasoning
strategy would be represented by sentences.  While some progress has been
made in representing facts about the effects of actions by logical sentences,
and non-monotonic reasoning has been formalized in various ways and added
to logical deduction as a means of deciding what to do, I don't know of
any progress in expressing reasoning heuristics declaratively.

	The present paper introduces the idea of mental situation as a
generalization of a database and applies it to formalizing heuristics.
Both in AI and in database theory, one normally thinks of a database as
a collection of sentences about some object domain.  If the computer
keeps any information about the inferential history of the sentences, as
RMS's do, this information is represented other than by sentences.  The
mental situations we introduce in this paper represent inferential
history also by sentences --- at least sentences about the history of
the database can be used as premisses in inferences.  The present
proposal can be regarded as a generalization of the RMS idea.  However,
the history information is represented declaratively itself and can be
used as premisses in arbitrary sentences used to decide what to do.

	Let there be some base language $L$ with a certain class of wffs.
The basic element of our database isn't a wff but an occurrence of
a wff.  We need occurrences rather than just wffs, because the same
wff may have been derived in different ways.  Here are our conventions.

We will list the variables ranging over various kinds of entities.  A
letter representing a variable with primes or subscripts has the same
range as the letter plain.  The letter $s$ is a situation variable.  $S$
is a situation constant.  The variable $P$ ranges over occurrences and
$p$ over wffs.

$wff(P)$ is the wff of which $P$ is an occurrence.

$occurrences(p,s)$ is the set of occurrences of the wff $p$, and $occurs(p,s)$
is an abbreviation of $occurrences(p,s) ≠ \{\}$.

	Mental events give rise to new situations.  $result(modus(P1,P2),s)$
is the situation that results from applying the modus ponens rule of inference
in the situation $s$.  If the rule is applicable, there is a new occurrence
of the result of the rule in this situation.  If the rule is inapplicable,
there is an occurrence of
%
$$fails(modus(P1,P2),s).$$
%
Thus we see that situations can be mentioned in sentences, although we provide
no way for a situation to refer to itself.

Uses of Mental Situations

	The most direct way to use a program that keeps track of mental situations
is manually, i.e. as a reasoning checker or interactive reasoner.  The user
manually issues commands like $modus(P1,P2)$.  Let's call such a program R1,
for ``reasoner-1''.  R1 needs many more commands, i.e. there need to be many
more mental actions before it can be as good an interactive theorem prover
as, say, Ketonen's (19xx) EKL.  For example, the use of sentences as rewrite
rules needs to be allowed.  Defining collections of sentences as rewrite rules
needs to result in sentences being put in the database.  R1 will be more
powerful than EKL, because it can include sentences that refer to mental
situations, i.e. the ones that arose earlier in the reasoning.  The database
can also include sentences that quantify over mental situations.

	The next step is a program that executes the mental action commands
and uses mental queries to decide what to do.  The key question is the
extent to which the reasoning strategy is imbedded in the program and
the extent to which it is represented in the mental situation itself.  The
goal is a very simple program with all strategy represented in the situation.

from notebook - 1987 Oct 24

active predicates

The rules for deciding what to do contain ``active predicates'' referring
to the current mental situation as well as static facts incorporated in
the mental situation.  The evaluation of an active predicate (active fluent)
results in a sentence about the situation being included in the resulting
situation, but it also as a dynamic effect in causing the rule to be
activated.

	Also the basic thinking mechanism may use stacks, but the state
of these stacks is also represented by sentences --- possibly only
virtual sentences.

***

Notes

1987 Dec 11

	The program that matches the test side of rules accepts as premisses
sentences from old versions of the database that haven't been actively
forgotten.  However, when it achieves a match, it checks whether the premisses
may all be considered current.  This is (normally) a dynamic process, i.e. it
doesn't add sentences to the database.